<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>时间轮算法：打造百万级定时任务调度系统的核心技术</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
            min-height: 100vh;
        }
        
        .hero-gradient {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        
        .content-card {
            background: rgba(255, 255, 255, 0.95);
            backdrop-filter: blur(10px);
            transition: all 0.3s ease;
        }
        
        .content-card:hover {
            transform: translateY(-2px);
            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
        }
        
        .section-title {
            position: relative;
            padding-left: 20px;
        }
        
        .section-title::before {
            content: '';
            position: absolute;
            left: 0;
            top: 50%;
            transform: translateY(-50%);
            width: 4px;
            height: 24px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            border-radius: 2px;
        }
        
        .code-block {
            background: #1e1e1e;
            color: #d4d4d4;
            border-radius: 8px;
            overflow-x: auto;
        }
        
        .code-block pre {
            margin: 0;
            padding: 20px;
            font-family: 'Consolas', 'Monaco', monospace;
            font-size: 14px;
            line-height: 1.6;
        }
        
        .highlight-box {
            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
            color: white;
            padding: 20px;
            border-radius: 12px;
            margin: 20px 0;
        }
        
        .feature-card {
            background: white;
            border-radius: 12px;
            padding: 24px;
            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.08);
            transition: all 0.3s ease;
        }
        
        .feature-card:hover {
            transform: translateY(-4px);
            box-shadow: 0 8px 30px rgba(0, 0, 0, 0.12);
        }
        
        .mermaid {
            background: white;
            padding: 20px;
            border-radius: 8px;
            margin: 20px 0;
        }
        
        .drop-cap {
            float: left;
            font-size: 4em;
            line-height: 0.8;
            margin: 0.1em 0.1em 0 0;
            font-weight: 700;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            font-family: 'Noto Serif SC', serif;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <div class="hero-gradient text-white py-20">
        <div class="container mx-auto px-6">
            <div class="max-w-4xl mx-auto text-center">
                <h1 class="text-5xl md:text-6xl font-bold mb-6 leading-tight">
                    时间轮算法
                </h1>
                <p class="text-2xl md:text-3xl mb-8 opacity-90">
                    打造百万级定时任务调度系统的核心技术
                </p>
                <div class="flex justify-center space-x-8 text-lg">
                    <div class="flex items-center">
                        <i class="fas fa-clock mr-2"></i>
                        <span>O(1) 时间复杂度</span>
                    </div>
                    <div class="flex items-center">
                        <i class="fas fa-server mr-2"></i>
                        <span>百万级并发</span>
                    </div>
                    <div class="flex items-center">
                        <i class="fas fa-memory mr-2"></i>
                        <span>极低内存占用</span>
                    </div>
                </div>
            </div>
        </div>
    </div>

    <!-- Main Content -->
    <div class="container mx-auto px-6 py-12">
        <div class="max-w-5xl mx-auto">
            
            <!-- Introduction -->
            <div class="content-card rounded-xl shadow-xl p-8 mb-8">
                <p class="text-lg leading-relaxed mb-6">
                    <span class="drop-cap">当</span>你的系统每秒需要处理数十万个定时任务时，普通的 setTimeout 和 setInterval 就显得捉襟见肘。想象一下，一个电商平台在双十一需要精确处理数百万个延时订单取消操作，或者一个即时通讯系统需要管理数千万用户的消息推送定时器，传统方案会让你的服务器负载飙升。
                </p>
                
                <div class="my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1751268175974-8c3793f0-a3aa-48c5-a1ad-55d9257d30aa.png" 
                         alt="时间轮算法示意图" 
                         class="w-full rounded-lg shadow-lg">
                </div>
                
                <p class="text-lg leading-relaxed">
                    时间轮算法正是为解决这类高并发定时任务而生，它如同一个精密钟表，能以极低的系统开销处理海量定时事件。今天，我将揭开这一算法的神秘面纱，带你掌握打造高性能定时系统的核心技术。
                </p>
            </div>

            <!-- Section 1: 定时器详解 -->
            <div class="content-card rounded-xl shadow-xl p-8 mb-8">
                <h2 class="section-title text-3xl font-bold mb-6 text-gray-800">
                    <i class="fas fa-hourglass-half mr-3 text-purple-600"></i>
                    一、定时器详解
                </h2>
                
                <div class="space-y-6">
                    <div>
                        <h3 class="text-2xl font-semibold mb-4 text-gray-700">1. 传统定时器的性能瓶颈</h3>
                        <p class="text-lg leading-relaxed mb-4">
                            在Java中，我们习惯使用<code class="bg-gray-100 px-2 py-1 rounded text-purple-600">Timer</code>类或者<code class="bg-gray-100 px-2 py-1 rounded text-purple-600">ScheduledThreadPoolExecutor</code>来处理定时任务。然而，当面临高并发场景时，这些传统方案会遇到几个关键瓶颈：
                        </p>
                        
                        <div class="grid md:grid-cols-3 gap-4 mb-6">
                            <div class="feature-card">
                                <i class="fas fa-chart-line text-3xl text-purple-600 mb-3"></i>
                                <h4 class="font-semibold mb-2">数据结构效率问题</h4>
                                <p class="text-gray-600">传统定时器通常使用优先队列（小顶堆）存储定时任务，每次插入和删除操作的时间复杂度为O(log n)</p>
                            </div>
                            <div class="feature-card">
                                <i class="fas fa-microchip text-3xl text-purple-600 mb-3"></i>
                                <h4 class="font-semibold mb-2">线程资源消耗</h4>
                                <p class="text-gray-600">每个定时任务可能需要一个线程来执行，大量任务会导致线程资源耗尽</p>
                            </div>
                            <div class="feature-card">
                                <i class="fas fa-memory text-3xl text-purple-600 mb-3"></i>
                                <h4 class="font-semibold mb-2">内存占用</h4>
                                <p class="text-gray-600">海量的定时任务对象会占用大量堆内存，增加GC压力</p>
                            </div>
                        </div>
                        
                        <div class="code-block">
                            <pre><code>ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);

// 创建一个延迟5秒执行的任务
scheduler.schedule(() -> {
    System.out.println("延迟任务执行");
}, 5, TimeUnit.SECONDS);

// 创建一个每3秒执行一次的周期任务
scheduler.scheduleAtFixedRate(() -> {
    System.out.println("周期任务执行");
}, 0, 3, TimeUnit.SECONDS);</code></pre>
                        </div>
                        
                        <p class="text-lg mt-4 text-gray-700">
                            当任务数量达到百万级别时，这种方案的性能显著下降，系统开销急剧上升。
                        </p>
                    </div>
                    
                    <div>
                        <h3 class="text-2xl font-semibold mb-4 text-gray-700">2. 高并发场景下的定时任务特点</h3>
                        <div class="highlight-box">
                            <h4 class="text-xl font-semibold mb-3">高并发系统中的定时任务通常具有以下特点：</h4>
                            <ul class="space-y-2">
                                <li><i class="fas fa-check-circle mr-2"></i><strong>数量庞大</strong>：可能同时存在数十万甚至数百万个定时任务</li>
                                <li><i class="fas fa-check-circle mr-2"></i><strong>触发时间密集</strong>：在某些时间点可能有大量任务同时触发</li>
                                <li><i class="fas fa-check-circle mr-2"></i><strong>精度要求各异</strong>：有些任务对时间精度要求高（如秒级触发），有些则可接受较低精度（分钟级）</li>
                                <li><i class="fas fa-check-circle mr-2"></i><strong>重复性</strong>：许多任务是周期性执行的，而非一次性</li>
                            </ul>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Section 2: 时间轮算法详解 -->
            <div class="content-card rounded-xl shadow-xl p-8 mb-8">
                <h2 class="section-title text-3xl font-bold mb-6 text-gray-800">
                    <i class="fas fa-cog mr-3 text-purple-600"></i>
                    二、时间轮算法详解
                </h2>
                
                <div class="space-y-6">
                    <div>
                        <h3 class="text-2xl font-semibold mb-4 text-gray-700">1. 时间轮的基本概念与结构</h3>
                        <p class="text-lg leading-relaxed mb-6">
                            时间轮本质上是一个循环数组，数组的每个槽位（slot）代表一个时间间隔，每个槽位上可以挂载该时间点需要执行的任务列表。想象一个钟表，时钟指针每次只移动一格，每一格对应一组任务，时针转到哪里就执行哪里的任务，这就是时间轮的基本思想。
                        </p>
                        
                        <div class="mermaid">
                            <script>
                                mermaid.initialize({ startOnLoad: true });
                            </script>
                            <div class="mermaid">
                                graph LR
                                    A[时间轮] --> B[槽位0]
                                    A --> C[槽位1]
                                    A --> D[槽位2]
                                    A --> E[...]
                                    A --> F[槽位N]
                                    B --> G[任务列表]
                                    C --> H[任务列表]
                                    D --> I[任务列表]
                                    F --> J[任务列表]
                                    
                                    style A fill:#667eea,stroke:#333,stroke-width:2px,color:#fff
                                    style B fill:#f093fb,stroke:#333,stroke-width:2px,color:#fff
                                    style C fill:#f093fb,stroke:#333,stroke-width:2px,color:#fff
                                    style D fill:#f093fb,stroke:#333,stroke-width:2px,color:#fff
                                    style F fill:#f093fb,stroke:#333,stroke-width:2px,color:#fff
                            </div>
                        </div>
                    </div>
                    
                    <div>
                        <h3 class="text-2xl font-semibold mb-4 text-gray-700">2. 单层时间轮实现原理</h3>
                        <p class="text-lg mb-4">单层时间轮由以下几部分组成：</p>
                        
                        <div class="grid md:grid-cols-